package com.ruoyi.common.utils;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 学号生成工具类
 * 生成规则：3位班级编码 + 9位不重复数字编码
 */
public class StudentNoUtils {
    // 使用ConcurrentHashMap存储每个班级的计数器
    private static final ConcurrentHashMap<String, AtomicInteger> classCounters = new ConcurrentHashMap<>();
    
    /**
     * 生成学号
     * @param classCode 班级编码（3位）
     * @return 完整学号（12位）
     */
    public static String generateStudentNo(String classCode) {
        if (classCode == null || classCode.length() != 3) {
            throw new IllegalArgumentException("班级编码必须为3位");
        }

        // 获取或创建该班级的计数器
        AtomicInteger counter = classCounters.computeIfAbsent(classCode, k -> new AtomicInteger(0));
        
        // 获取并递增计数器，确保不超过9位数
        int sequence = counter.incrementAndGet();
        if (sequence > 999999999) {
            throw new RuntimeException("该班级学号序列已达到最大值");
        }
        
        // 格式化9位序列号，不足位数补0
        return classCode + String.format("%09d", sequence);
    }

    /**
     * 重置指定班级的计数器
     * @param classCode 班级编码
     */
    public static void resetCounter(String classCode) {
        classCounters.remove(classCode);
    }

    /**
     * 清空所有计数器
     */
    public static void resetAllCounters() {
        classCounters.clear();
    }

    /**
     * 多线程测试方法
     */
    /*public static void main(String[] args) {
        // 测试参数
        final String testClassCode = "101";
        final int threadCount = 10;
        final int studentsPerThread = 1000;
        
        // 用于收集所有生成的学号
        Set<String> allStudentNos = new HashSet<>();
        CountDownLatch latch = new CountDownLatch(threadCount);
        
        // 重置计数器
        resetAllCounters();
        
        // 创建多个线程同时生成学号
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    Set<String> threadStudentNos = new HashSet<>();
                    for (int j = 0; j < studentsPerThread; j++) {
                        String studentNo = generateStudentNo(testClassCode);
                        if (!threadStudentNos.add(studentNo)) {
                            System.err.println("线程内部发现重复学号: " + studentNo);
                        }
                    }
                    synchronized (allStudentNos) {
                        for (String studentNo : threadStudentNos) {
                            if (!allStudentNos.add(studentNo)) {
                                System.err.println("不同线程间发现重复学号: " + studentNo);
                            }
                        }
                    }
                } finally {
                    latch.countDown();
                }
            }).start();
        }
        
        try {
            // 等待所有线程完成
            latch.await();
            
            // 验证结果
            int expectedCount = threadCount * studentsPerThread;
            int actualCount = allStudentNos.size();
            
            System.out.println("测试完成:");
            System.out.println("预期生成学号数量: " + expectedCount);
            System.out.println("实际生成学号数量: " + actualCount);
            System.out.println("是否存在重复: " + (expectedCount != actualCount));
            
            // 输出一些示例学号
            System.out.println("\n学号示例:");
            allStudentNos.stream().limit(5).forEach(System.out::println);
            
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("测试被中断");
        }
    }*/
}